પાયથન ટાઇપ હિન્ટ્સનો વિકાસ: જેનરિક ટાઇપ્સ વિરુદ્ધ પ્રોટોકોલનો ઉપયોગ

પાયથન, જે તેના ડાયનેમિક ટાઇપિંગ માટે જાણીતું છે, તેણે કોડની વાંચનક્ષમતા, જાળવણીક્ષમતા અને મજબૂતાઈ વધારવા માટે PEP 484 (પાયથન 3.5) માં ટાઇપ હિન્ટ્સ રજૂ કર્યા. જ્યારે શરૂઆતમાં મૂળભૂત હતી, ટાઇપ હિન્ટિંગ સિસ્ટમ નોંધપાત્ર રીતે વિકસિત થઈ છે, જેમાં જેનરિક ટાઇપ્સ અને પ્રોટોકોલ્સ અત્યાધુનિક અને સારી રીતે ટાઇપ થયેલ પાયથન કોડ લખવા માટે આવશ્યક સાધનો બની ગયા છે. આ બ્લોગ પોસ્ટ પાયથન ટાઇપ હિન્ટ્સના વિકાસની શોધ કરે છે, જેનરિક ટાઇપ્સ અને પ્રોટોકોલના ઉપયોગ પર ધ્યાન કેન્દ્રિત કરે છે, અને તમને આ શક્તિશાળી સુવિધાઓનો લાભ લેવામાં મદદ કરવા માટે વ્યવહારુ ઉદાહરણો અને આંતરદૃષ્ટિ પ્રદાન કરે છે.

ટાઇપ હિન્ટ્સની મૂળભૂત બાબતો

જેનરિક ટાઇપ્સ અને પ્રોટોકોલ્સમાં ઊંડા ઉતરતા પહેલાં, ચાલો પાયથન ટાઇપ હિન્ટ્સના મૂળભૂત સિદ્ધાંતોને ફરી જોઈએ. ટાઇપ હિન્ટ્સ તમને વેરીએબલ્સ, ફંક્શન આર્ગ્યુમેન્ટ્સ અને રિટર્ન વેલ્યુઝના અપેક્ષિત ડેટા ટાઇપનો ઉલ્લેખ કરવાની મંજૂરી આપે છે. આ માહિતીનો ઉપયોગ પછી mypy જેવા સ્ટેટિક એનાલિસિસ ટૂલ્સ દ્વારા રનટાઇમ પહેલાં ટાઇપ એરર્સ શોધવા માટે કરવામાં આવે છે.

અહીં એક સરળ ઉદાહરણ છે:

            def greet(name: str) -> str:
    return f"Hello, {name}!"

print(greet("Alice"))

            

              
                Copy
              
            
          

આ ઉદાહરણમાં, name: str સ્પષ્ટ કરે છે કે name આર્ગ્યુમેન્ટ સ્ટ્રિંગ હોવો જોઈએ, અને -> str સૂચવે છે કે ફંક્શન સ્ટ્રિંગ રિટર્ન કરે છે. જો તમે greet() માં ઇન્ટિજર પાસ કરશો, તો mypy તેને ટાઇપ એરર તરીકે ફ્લેગ કરશે.

જેનરિક ટાઇપ્સનો પરિચય

જેનરિક ટાઇપ્સ તમને ટાઇપ સેફ્ટી સાથે સમાધાન કર્યા વિના અનેક ડેટા પ્રકારો સાથે કામ કરતો કોડ લખવાની મંજૂરી આપે છે. તે ખાસ કરીને લિસ્ટ, ડિક્શનરી અને સેટ જેવા કલેક્શન્સ સાથે કામ કરતી વખતે ઉપયોગી છે. જેનરિક ટાઇપ્સ પહેલાં, તમે typing.List, typing.Dict, અને typing.Set નો ઉપયોગ કરી શકતા હતા, પરંતુ તમે તે કલેક્શન્સની અંદરના એલિમેન્ટ્સના ટાઇપ્સનો ઉલ્લેખ કરી શકતા ન હતા.

જેનરિક ટાઇપ્સ આ મર્યાદાને દૂર કરે છે અને તમને કલેક્શન ટાઇપ્સને તેમના એલિમેન્ટ્સના ટાઇપ્સ સાથે પેરામીટરાઇઝ કરવાની મંજૂરી આપે છે. ઉદાહરણ તરીકે, List[str] સ્ટ્રિંગ્સની લિસ્ટનું પ્રતિનિધિત્વ કરે છે, અને Dict[str, int] સ્ટ્રિંગ કીઝ અને ઇન્ટિજર વેલ્યુઝવાળી ડિક્શનરીનું પ્રતિનિધિત્વ કરે છે.

અહીં લિસ્ટ સાથે જેનરિક ટાઇપ્સનો ઉપયોગ કરવાનું ઉદાહરણ છે:

            from typing import List

def process_names(names: List[str]) -> List[str]:
    upper_case_names: List[str] = [name.upper() for name in names]
    return upper_case_names

names = ["Alice", "Bob", "Charlie"]
upper_case_names = process_names(names)
print(upper_case_names)

            

              
                Copy
              
            
          

આ ઉદાહરણમાં, List[str] સુનિશ્ચિત કરે છે કે names આર્ગ્યુમેન્ટ અને upper_case_names વેરીએબલ બંને સ્ટ્રિંગ્સની લિસ્ટ છે. જો તમે આમાંથી કોઈ પણ લિસ્ટમાં નોન-સ્ટ્રિંગ એલિમેન્ટ ઉમેરવાનો પ્રયાસ કરશો, તો mypy ટાઇપ એરરની જાણ કરશે.

કસ્ટમ ક્લાસીસ સાથે જેનરિક ટાઇપ્સ

તમે તમારા પોતાના ક્લાસીસ સાથે પણ જેનરિક ટાઇપ્સનો ઉપયોગ કરી શકો છો. આ કરવા માટે, તમારે typing.TypeVar ક્લાસનો ઉપયોગ કરીને એક ટાઇપ વેરીએબલ વ્યાખ્યાયિત કરવાની જરૂર છે, જેનો ઉપયોગ તમે તમારા ક્લાસને પેરામીટરાઇઝ કરવા માટે કરી શકો છો.

અહીં એક ઉદાહરણ છે:

            from typing import TypeVar, Generic

T = TypeVar('T')

class Box(Generic[T]):
    def __init__(self, content: T):
        self.content = content

    def get_content(self) -> T:
        return self.content

box_int = Box[int](10)
box_str = Box[str]("Hello")

print(box_int.get_content())
print(box_str.get_content())

            

              
                Copy
              
            
          

આ ઉદાહરણમાં, T = TypeVar('T') એ T નામનો ટાઇપ વેરીએબલ વ્યાખ્યાયિત કરે છે. Box ક્લાસ પછી Generic[T] નો ઉપયોગ કરીને T સાથે પેરામીટરાઇઝ થાય છે. આ તમને Box[int] અને Box[str] જેવા વિવિધ કન્ટેન્ટ ટાઇપ્સ સાથે Box ના ઇન્સ્ટન્સ બનાવવાની મંજૂરી આપે છે. get_content() મેથડ કન્ટેન્ટના સમાન ટાઇપની વેલ્યુ રિટર્ન કરે છે.

`Any` અને `TypeAlias` નો ઉપયોગ

કેટલીકવાર, તમારે અજ્ઞાત પ્રકારોની વેલ્યુઝ સાથે કામ કરવાની જરૂર પડી શકે છે. આવા કિસ્સાઓમાં, તમે typing મોડ્યુલમાંથી Any ટાઇપનો ઉપયોગ કરી શકો છો. Any જે વેરીએબલ અથવા ફંક્શન આર્ગ્યુમેન્ટ પર લાગુ થાય છે તેના માટે ટાઇપ ચેકિંગને અસરકારક રીતે નિષ્ક્રિય કરે છે.

            from typing import Any

def process_data(data: Any):
    # We don't know the type of 'data', so we can't perform type-specific operations
    print(f"Processing data: {data}")

process_data(10)
process_data("Hello")
process_data([1, 2, 3])

            

              
                Copy
              
            
          

જ્યારે Any અમુક પરિસ્થિતિઓમાં ઉપયોગી થઈ શકે છે, ત્યારે શક્ય હોય ત્યાં સુધી તેને ટાળવું શ્રેષ્ઠ છે, કારણ કે તે ટાઇપ ચેકિંગના ફાયદાઓને નબળા પાડી શકે છે.

TypeAlias તમને જટિલ ટાઇપ હિન્ટ્સ માટે ઉપનામ બનાવવાની મંજૂરી આપે છે, જે તમારા કોડને વધુ વાંચનીય અને જાળવણી કરી શકાય તેવો બનાવે છે.

            from typing import List, Tuple, TypeAlias

Point: TypeAlias = Tuple[float, float]
Line: TypeAlias = Tuple[Point, Point]

def calculate_distance(line: Line) -> float:
    x1, y1 = line[0]
    x2, y2 = line[1]
    return ((x2 - x1)**2 + (y2 - y1)**2)**0.5

my_line: Line = ((0.0, 0.0), (3.0, 4.0))
distance = calculate_distance(my_line)
print(f"The distance is: {distance}")

            

              
                Copy
              
            
          

આ ઉદાહરણમાં, Point એ Tuple[float, float] માટેનું ઉપનામ છે, અને Line એ Tuple[Point, Point] માટેનું ઉપનામ છે. આ calculate_distance() ફંક્શનમાં ટાઇપ હિન્ટ્સને વધુ વાંચનીય બનાવે છે.

પ્રોટોકોલ્સને સમજવું

પ્રોટોકોલ્સ PEP 544 (પાયથન 3.8) માં રજૂ કરાયેલ એક શક્તિશાળી સુવિધા છે જે તમને સ્ટ્રક્ચરલ સબટાઇપિંગ (જેને ડક ટાઇપિંગ તરીકે પણ ઓળખવામાં આવે છે) ના આધારે ઇન્ટરફેસ વ્યાખ્યાયિત કરવાની મંજૂરી આપે છે. જાવા અથવા C# જેવી ભાષાઓમાં પરંપરાગત ઇન્ટરફેસથી વિપરીત, પ્રોટોકોલ્સને સ્પષ્ટ વારસાની જરૂર નથી. તેના બદલે, એક ક્લાસ પ્રોટોકોલને અમલમાં મૂકેલો માનવામાં આવે છે જો તે સાચા ટાઇપ્સ સાથે જરૂરી મેથડ્સ અને એટ્રિબ્યુટ્સ પ્રદાન કરે છે.

આ પ્રોટોકોલ્સને પરંપરાગત ઇન્ટરફેસ કરતાં વધુ લવચીક અને ઓછા કર્કશ બનાવે છે, કારણ કે તમારે હાલના ક્લાસીસને પ્રોટોકોલનું પાલન કરાવવા માટે તેમાં ફેરફાર કરવાની જરૂર નથી. આ ખાસ કરીને તૃતીય-પક્ષ લાઇબ્રેરીઓ અથવા લેગસી કોડ સાથે કામ કરતી વખતે ઉપયોગી છે.

અહીં પ્રોટોકોલનું એક સરળ ઉદાહરણ છે:

            from typing import Protocol

class SupportsRead(Protocol):
    def read(self, size: int) -> str:
        ...

def process_data(reader: SupportsRead) -> str:
    data = reader.read(1024)
    return data.upper()

class FileReader:
    def read(self, size: int) -> str:
        with open("data.txt", "r") as f:
            return f.read(size)

class NetworkReader:
    def read(self, size: int) -> str:
        # Simulate reading from a network connection
        return "Network data..."

file_reader = FileReader()
network_reader = NetworkReader()

data_from_file = process_data(file_reader)
data_from_network = process_data(network_reader)

print(f"Data from file: {data_from_file}")
print(f"Data from network: {data_from_network}")

            

              
                Copy
              
            
          

આ ઉદાહરણમાં, SupportsRead એક પ્રોટોકોલ છે જે read() મેથડને વ્યાખ્યાયિત કરે છે જે ઇનપુટ તરીકે ઇન્ટિજર size લે છે અને સ્ટ્રિંગ રિટર્ન કરે છે. process_data() ફંક્શન કોઈપણ ઑબ્જેક્ટને સ્વીકારે છે જે SupportsRead પ્રોટોકોલનું પાલન કરે છે.

FileReader અને NetworkReader બંને ક્લાસ સાચી સિગ્નેચર સાથે read() મેથડને અમલમાં મૂકે છે, તેથી તેઓ SupportsRead પ્રોટોકોલનું પાલન કરતા માનવામાં આવે છે, ભલે તેઓ સ્પષ્ટપણે તેમાંથી વારસો ન મેળવતા હોય. આ તમને બંને ક્લાસના ઇન્સ્ટન્સને process_data() ફંક્શનમાં પાસ કરવાની મંજૂરી આપે છે.

જેનરિક ટાઇપ્સ અને પ્રોટોકોલ્સનું સંયોજન

તમે વધુ શક્તિશાળી અને લવચીક ટાઇપ હિન્ટ્સ બનાવવા માટે જેનરિક ટાઇપ્સ અને પ્રોટોકોલ્સને પણ જોડી શકો છો. ઉદાહરણ તરીકે, તમે એક પ્રોટોકોલ વ્યાખ્યાયિત કરી શકો છો જેને એક મેથડની જરૂર હોય જે ચોક્કસ પ્રકારની વેલ્યુ રિટર્ન કરે, જ્યાં ટાઇપ જેનરિક ટાઇપ વેરીએબલ દ્વારા નક્કી થાય છે.

અહીં એક ઉદાહરણ છે:

            from typing import Protocol, TypeVar, Generic

T = TypeVar('T')

class SupportsConvert(Protocol, Generic[T]):
    def convert(self) -> T:
        ...

class StringConverter:
    def convert(self) -> str:
        return "Hello"

class IntConverter:
    def convert(self) -> int:
        return 10

def process_converter(converter: SupportsConvert[int]) -> int:
    return converter.convert() + 5

int_converter = IntConverter()
result = process_converter(int_converter)
print(result)

            

              
                Copy
              
            
          

આ ઉદાહરણમાં, SupportsConvert એ એક પ્રોટોકોલ છે જે ટાઇપ વેરીએબલ T સાથે પેરામીટરાઇઝ થયેલ છે. convert() મેથડને T ટાઇપની વેલ્યુ રિટર્ન કરવી જરૂરી છે. process_converter() ફંક્શન કોઈપણ ઑબ્જેક્ટને સ્વીકારે છે જે SupportsConvert[int] પ્રોટોકોલનું પાલન કરે છે, જેનો અર્થ છે કે તેની convert() મેથડ ઇન્ટિજર રિટર્ન કરવી આવશ્યક છે.

પ્રોટોકોલ્સ માટે વ્યવહારુ ઉપયોગના કિસ્સાઓ

પ્રોટોકોલ્સ વિવિધ પરિદ્રશ્યોમાં ખાસ કરીને ઉપયોગી છે, જેમાં નીચેનાનો સમાવેશ થાય છે:

• ડિપેન્ડન્સી ઇન્જેક્શન: પ્રોટોકોલ્સનો ઉપયોગ ડિપેન્ડન્સીના ઇન્ટરફેસને વ્યાખ્યાયિત કરવા માટે થઈ શકે છે, જે તમને તેનો ઉપયોગ કરતા કોડમાં ફેરફાર કર્યા વિના વિવિધ અમલીકરણોને સરળતાથી બદલવાની મંજૂરી આપે છે. ઉદાહરણ તરીકે, તમે ડેટાબેઝ કનેક્શનના ઇન્ટરફેસને વ્યાખ્યાયિત કરવા માટે પ્રોટોકોલનો ઉપયોગ કરી શકો છો, જે તમને ડેટાબેઝ એક્સેસ કરતા કોડમાં ફેરફાર કર્યા વિના વિવિધ ડેટાબેઝ સિસ્ટમ્સ વચ્ચે સ્વિચ કરવાની મંજૂરી આપે છે.
• ટેસ્ટિંગ: પ્રોટોકોલ્સ તમને મોક ઑબ્જેક્ટ્સ બનાવવાની મંજૂરી આપીને યુનિટ ટેસ્ટ લખવાનું સરળ બનાવે છે જે વાસ્તવિક ઑબ્જેક્ટ્સ જેવા જ ઇન્ટરફેસનું પાલન કરે છે. આ તમને ટેસ્ટ કરવામાં આવતા કોડને અલગ કરવાની અને બાહ્ય સિસ્ટમો પરની નિર્ભરતાને ટાળવાની મંજૂરી આપે છે. દાખલા તરીકે, તમે ફાઇલ સિસ્ટમના ઇન્ટરફેસને વ્યાખ્યાયિત કરવા માટે પ્રોટોકોલનો ઉપયોગ કરી શકો છો, જે તમને ટેસ્ટિંગ હેતુઓ માટે મોક ફાઇલ સિસ્ટમ બનાવવાની મંજૂરી આપે છે.
• એબ્સ્ટ્રેક્ટ ડેટા ટાઇપ્સ: પ્રોટોકોલ્સનો ઉપયોગ એબ્સ્ટ્રેક્ટ ડેટા ટાઇપ્સને વ્યાખ્યાયિત કરવા માટે થઈ શકે છે, જે ઇન્ટરફેસ છે જે ડેટા ટાઇપના વર્તનને તેના અમલીકરણનો ઉલ્લેખ કર્યા વિના સ્પષ્ટ કરે છે. આ તમને ડેટા સ્ટ્રક્ચર્સ બનાવવાની મંજૂરી આપે છે જે અંતર્ગત અમલીકરણથી સ્વતંત્ર હોય છે. ઉદાહરણ તરીકે, તમે સ્ટેક અથવા ક્યુના ઇન્ટરફેસને વ્યાખ્યાયિત કરવા માટે પ્રોટોકોલનો ઉપયોગ કરી શકો છો.
• પ્લગઇન સિસ્ટમ્સ: પ્રોટોકોલ્સનો ઉપયોગ પ્લગઇન્સના ઇન્ટરફેસને વ્યાખ્યાયિત કરવા માટે થઈ શકે છે, જે તમને એપ્લિકેશનના કોર કોડમાં ફેરફાર કર્યા વિના તેની કાર્યક્ષમતાને સરળતાથી વિસ્તારવાની મંજૂરી આપે છે. ઉદાહરણ તરીકે, તમે પેમેન્ટ ગેટવેના ઇન્ટરફેસને વ્યાખ્યાયિત કરવા માટે પ્રોટોકોલનો ઉપયોગ કરી શકો છો, જે તમને કોર પેમેન્ટ પ્રોસેસિંગ લોજિકમાં ફેરફાર કર્યા વિના નવી પેમેન્ટ પદ્ધતિઓ માટે સપોર્ટ ઉમેરવાની મંજૂરી આપે છે.

ટાઇપ હિન્ટ્સનો ઉપયોગ કરવા માટેની શ્રેષ્ઠ પદ્ધતિઓ

પાયથન ટાઇપ હિન્ટ્સનો મહત્તમ લાભ લેવા માટે, નીચેની શ્રેષ્ઠ પદ્ધતિઓનો વિચાર કરો:

• સુસંગત રહો: તમારા સમગ્ર કોડબેઝમાં ટાઇપ હિન્ટ્સનો સુસંગત રીતે ઉપયોગ કરો. ટાઇપ હિન્ટ્સનો અસંગત ઉપયોગ ગૂંચવણ તરફ દોરી શકે છે અને ટાઇપ એરર્સ શોધવાનું મુશ્કેલ બનાવી શકે છે.
• નાની શરૂઆત કરો: જો તમે હાલના કોડબેઝમાં ટાઇપ હિન્ટ્સ રજૂ કરી રહ્યા હોવ, તો કોડના નાના, વ્યવસ્થાપિત વિભાગથી શરૂઆત કરો અને સમય જતાં ધીમે ધીમે ટાઇપ હિન્ટ્સનો ઉપયોગ વિસ્તારો.
• સ્ટેટિક એનાલિસિસ ટૂલ્સનો ઉપયોગ કરો: ટાઇપ એરર્સ માટે તમારા કોડને તપાસવા માટે mypy જેવા સ્ટેટિક એનાલિસિસ ટૂલ્સનો ઉપયોગ કરો. આ ટૂલ્સ તમને વિકાસ પ્રક્રિયામાં વહેલી તકે ભૂલો પકડવામાં મદદ કરી શકે છે, તે રનટાઇમ પર સમસ્યાઓ ઊભી કરે તે પહેલાં.
• સ્પષ્ટ અને સંક્ષિપ્ત ટાઇપ હિન્ટ્સ લખો: એવા ટાઇપ હિન્ટ્સ લખો જે સમજવામાં અને જાળવવામાં સરળ હોય. વધુ પડતા જટિલ ટાઇપ હિન્ટ્સ ટાળો જે તમારા કોડને વાંચવામાં મુશ્કેલ બનાવી શકે છે.
• ટાઇપ એલિયાસનો ઉપયોગ કરો: જટિલ ટાઇપ હિન્ટ્સને સરળ બનાવવા અને તમારા કોડને વધુ વાંચનીય બનાવવા માટે ટાઇપ એલિયાસનો ઉપયોગ કરો.
• `Any` નો વધુ પડતો ઉપયોગ ન કરો: અત્યંત જરૂરી ન હોય ત્યાં સુધી Any નો ઉપયોગ કરવાનું ટાળો. Any નો વધુ પડતો ઉપયોગ ટાઇપ ચેકિંગના ફાયદાઓને નબળા પાડી શકે છે.
• તમારા ટાઇપ હિન્ટ્સનું દસ્તાવેજીકરણ કરો: તમારા ટાઇપ હિન્ટ્સનું દસ્તાવેજીકરણ કરવા માટે ડોકસ્ટ્રિંગ્સનો ઉપયોગ કરો, દરેક ટાઇપના હેતુ અને તેના પર લાગુ થતી કોઈપણ મર્યાદાઓ અથવા ધારણાઓને સમજાવો.
• રનટાઇમ ટાઇપ ચેકિંગનો વિચાર કરો: જ્યારે પાયથન સ્ટેટિકલી ટાઇપ નથી, ત્યારે `beartype` જેવી લાઇબ્રેરીઓ રનટાઇમ પર ટાઇપ હિન્ટ્સ લાગુ કરવા માટે રનટાઇમ ટાઇપ ચેકિંગ પ્રદાન કરે છે, જે ખાસ કરીને બાહ્ય ડેટા અથવા ડાયનેમિક કોડ જનરેશન સાથે કામ કરતી વખતે સુરક્ષાનું વધારાનું સ્તર પૂરું પાડે છે.

ઉદાહરણ: વૈશ્વિક ઈ-કોમર્સ એપ્લિકેશનમાં ટાઇપ હિન્ટ્સ

વૈશ્વિક સ્તરે વપરાશકર્તાઓને સેવા આપતી એક સરળ ઈ-કોમર્સ એપ્લિકેશનનો વિચાર કરો. અમે કોડની ગુણવત્તા અને જાળવણીક્ષમતા સુધારવા માટે ટાઇપ હિન્ટ્સ, જેનરિક્સ અને પ્રોટોકોલ્સનો ઉપયોગ કરી શકીએ છીએ.

            from typing import List, Dict, Protocol, TypeVar, Generic

# Define data types
UserID = str  # Example: UUID string
ProductID = str  # Example: SKU string
CurrencyCode = str  # Example: "USD", "EUR", "JPY"


class Product(Protocol):
    product_id: ProductID
    name: str
    price: float  # Base price in a standard currency (e.g., USD)


class DiscountRule(Protocol):
    def apply_discount(self, product: Product, user_id: UserID) -> float:  # Returns discount amount
        ...


class TaxCalculator(Protocol):
    def calculate_tax(self, product: Product, user_id: UserID, currency: CurrencyCode) -> float:
        ...


class PaymentGateway(Protocol):
    def process_payment(self, user_id: UserID, amount: float, currency: CurrencyCode) -> bool:
        ...


# Concrete implementations (examples)
class BasicProduct:
    def __init__(self, product_id: ProductID, name: str, price: float):
        self.product_id = product_id
        self.name = name
        self.price = price

class PercentageDiscount:
    def __init__(self, discount_percentage: float):
        self.discount_percentage = discount_percentage

    def apply_discount(self, product: Product, user_id: UserID) -> float:
        return product.price * (self.discount_percentage / 100)


class EuropeanVATCalculator:
    def calculate_tax(self, product: Product, user_id: UserID, currency: CurrencyCode) -> float:
        # Simplified EU VAT calculation (replace with actual logic)
        vat_rate = 0.20  # Example: 20% VAT
        return product.price * vat_rate


class CreditCardGateway:
    def process_payment(self, user_id: UserID, amount: float, currency: CurrencyCode) -> bool:
        # Simulate credit card processing
        print(f"Processing payment of {amount} {currency} for user {user_id} using credit card...")
        return True


# Type-hinted shopping cart function
def calculate_total(
    products: List[Product],
    user_id: UserID,
    currency: CurrencyCode,
    discount_rules: List[DiscountRule],
    tax_calculator: TaxCalculator,
    payment_gateway: PaymentGateway,
) -> float:
    total = 0.0
    for product in products:
        discount = 0.0
        for rule in discount_rules:
            discount += rule.apply_discount(product, user_id)

        tax = tax_calculator.calculate_tax(product, user_id, currency)
        total += product.price - discount + tax

    # Process payment
    if payment_gateway.process_payment(user_id, total, currency):
        return total
    else:
        raise Exception("Payment failed")


# Example usage
product1 = BasicProduct(product_id="SKU123", name="Awesome T-Shirt", price=25.0)
product2 = BasicProduct(product_id="SKU456", name="Cool Mug", price=15.0)

discount1 = PercentageDiscount(10)

vat_calculator = EuropeanVATCalculator()
payment_gateway = CreditCardGateway()

shopping_cart = [product1, product2]
user_id = "user123"
currency = "EUR"

final_total = calculate_total(
    products=shopping_cart,
    user_id=user_id,
    currency=currency,
    discount_rules=[discount1],
    tax_calculator=vat_calculator,
    payment_gateway=payment_gateway,
)

print(f"Total cost: {final_total} {currency}")

            

              
                Copy
              
            
          

આ ઉદાહરણમાં:

• અમે વાંચનક્ષમતા અને જાળવણીક્ષમતા સુધારવા માટે UserID, ProductID, અને CurrencyCode જેવા ટાઇપ એલિયાસનો ઉપયોગ કરીએ છીએ.
• અમે વિવિધ ઘટકો માટે ઇન્ટરફેસનું પ્રતિનિધિત્વ કરવા માટે પ્રોટોકોલ્સ (Product, DiscountRule, TaxCalculator, PaymentGateway) વ્યાખ્યાયિત કરીએ છીએ. આ અમને કોર calculate_total ફંક્શનમાં ફેરફાર કર્યા વિના વિવિધ અમલીકરણોને (ઉદાહરણ તરીકે, કોઈ અલગ પ્રદેશ માટે અલગ ટેક્સ કેલ્ક્યુલેટર) સરળતાથી બદલવાની મંજૂરી આપે છે.
• અમે કલેક્શન્સના પ્રકારોને વ્યાખ્યાયિત કરવા માટે જેનરિક્સનો ઉપયોગ કરીએ છીએ (ઉદાહરણ તરીકે, List[Product]).
• calculate_total ફંક્શન સંપૂર્ણપણે ટાઇપ-હિન્ટેડ છે, જે તેના ઇનપુટ્સ અને આઉટપુટ્સને સમજવાનું અને ટાઇપ એરર્સને વહેલી તકે પકડવાનું સરળ બનાવે છે.

આ ઉદાહરણ દર્શાવે છે કે વાસ્તવિક-વિશ્વ એપ્લિકેશનમાં વધુ મજબૂત, જાળવી શકાય તેવો અને ટેસ્ટ કરી શકાય તેવો કોડ લખવા માટે ટાઇપ હિન્ટ્સ, જેનરિક્સ અને પ્રોટોકોલ્સનો કેવી રીતે ઉપયોગ કરી શકાય છે.

નિષ્કર્ષ

પાયથન ટાઇપ હિન્ટ્સ, ખાસ કરીને જેનરિક ટાઇપ્સ અને પ્રોટોકોલ્સ, એ મજબૂત, જાળવી શકાય તેવા અને માપી શકાય તેવા કોડ લખવા માટે ભાષાની ક્ષમતાઓમાં નોંધપાત્ર વધારો કર્યો છે. આ સુવિધાઓને અપનાવીને, વિકાસકર્તાઓ કોડની ગુણવત્તા સુધારી શકે છે, રનટાઇમ એરર્સ ઘટાડી શકે છે અને ટીમોમાં સહયોગને સરળ બનાવી શકે છે. જેમ જેમ પાયથન ઇકોસિસ્ટમ વિકસતી રહેશે, તેમ તેમ ઉચ્ચ-ગુણવત્તાવાળા સોફ્ટવેર બનાવવા માટે ટાઇપ હિન્ટ્સમાં નિપુણતા મેળવવી વધુને વધુ નિર્ણાયક બનશે. ટાઇપ હિન્ટ્સના સંપૂર્ણ લાભો લેવા અને વિકાસ પ્રક્રિયામાં સંભવિત ભૂલોને વહેલી તકે પકડવા માટે mypy જેવા સ્ટેટિક એનાલિસિસ ટૂલ્સનો ઉપયોગ કરવાનું યાદ રાખો. વ્યવહારુ અનુભવ મેળવવા અને વાસ્તવિક-વિશ્વના પરિદ્રશ્યોમાં તેમના એપ્લિકેશન્સની ઊંડી સમજ મેળવવા માટે એડવાન્સ્ડ ટાઇપિંગ સુવિધાઓનો ઉપયોગ કરતી વિવિધ લાઇબ્રેરીઓ અને ફ્રેમવર્કનું અન્વેષણ કરો.